28 research outputs found
Deep Recurrent Architectures for Seismic Tomography
This paper introduces novel deep recurrent neural network architectures for
Velocity Model Building (VMB), which is beyond what Araya-Polo et al 2018
pioneered with the Machine Learning-based seismic tomography built with
convolutional non-recurrent neural network. Our investigation includes the
utilization of basic recurrent neural network (RNN) cells, as well as Long
Short Term Memory (LSTM) and Gated Recurrent Unit (GRU) cells. Performance
evaluation reveals that salt bodies are consistently predicted more accurately
by GRU and LSTM-based architectures, as compared to non-recurrent
architectures. The results take us a step closer to the final goal of a
reliable fully Machine Learning-based tomography from pre-stack data, which
when achieved will reduce the VMB turnaround from weeks to days.Comment: Published in the 81st EAGE Conference and Exhibition, 201
Enabling user-driven Checkpointing strategies in Reverse-mode Automatic Differentiation
This paper presents a new functionality of the Automatic Differentiation (AD) tool Tapenade. Tapenade generates adjoint codes which are widely used for optimization or inverse problems. Unfortunately, for large applications the adjoint code demands a great deal of memory, because it needs to store a large set of intermediates values. To cope with that problem, Tapenade implements a sub-optimal version of a technique called checkpointing, which is a trade-off between storage and recomputation. Our long-term goal is to provide an optimal checkpointing strategy for every code, not yet achieved by any AD tool. Towards that goal, we first introduce modifications in Tapenade in order to give the user the choice to select the checkpointing strategy most suitable for their code. Second, we conduct experiments in real-size scientific codes in order to gather hints that help us to deduce an optimal checkpointing strategy. Some of the experimental results show memory savings up to 35% and execution time up to 90%
Domain of Validity of Derivatives Computed by Automatic Differentiation
Automatic Differentiation (AD) is a technique to obtain derivatives of the functions computed by a computer program. Due to the control flow, these derivatives are valid only in a certain domain around the current input values. We investigate methods to evaluate this domain. This results in a new specific mode of AD that returns additional information on the domain of validity
STRIDE: Structure-guided Generation for Inverse Design of Molecules
Machine learning and especially deep learning has had an increasing impact on
molecule and materials design. In particular, given the growing access to an
abundance of high-quality small molecule data for generative modeling for drug
design, results for drug discovery have been promising. However, for many
important classes of materials such as catalysts, antioxidants, and
metal-organic frameworks, such large datasets are not available. Such families
of molecules with limited samples and structural similarities are especially
prevalent for industrial applications. As is well-known, retraining and even
fine-tuning are challenging on such small datasets. Novel, practically
applicable molecules are most often derivatives of well-known molecules,
suggesting approaches to addressing data scarcity. To address this problem, we
introduce , a generative molecule workflow that generates
novel molecules with an unconditional generative model guided by known
molecules without any retraining. We generate molecules outside of the training
data from a highly specialized set of antioxidant molecules. Our generated
molecules have on average 21.7% lower synthetic accessibility scores and also
reduce ionization potential by 5.9% of generated molecules via guiding
Evaluating Performance of OpenMP Tasks in a Seismic Stencil Application
Simulations based on stencil computations (widely used in geosciences) have been dominated by the MPI+OpenMP programming model paradigm. Little effort has been devoted to experimenting with task-based parallelism in this context. We address this by introducing OpenMP task parallelism into the kernel of an industrial seismic modeling code, Minimod. We observe that even for these highly regular stencil computations, taskified kernels are competitive with traditional OpenMP-augmented loops, and in some experiments tasks even outperform loop parallelism.
This promising result sets the stage for more complex computational patterns. Simulations involve more than just the stencil calculation: a collection of kernels is often needed to accomplish the scientific objective (e.g., I/O, boundary conditions). These kernels can often be computed simultaneously; however, implementing this simultaneous computation with traditional programming models is not trivial. The presented approach will be extended to cover simultaneous execution of several kernels, where we expect to fully exploit the benefits of task-based programming